home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / bin / ucfq < prev    next >
Text File  |  2008-05-30  |  19KB  |  848 lines
  1. #!/usr/bin/perl
  2. #                              -*- Mode: Cperl -*- 
  3. # ucfq --- 
  4. # Author           : Manoj Srivastava ( srivasta@glaurung.internal.golden-gryphon.com ) 
  5. # Created On       : Wed Apr 12 14:51:16 2006
  6. # Created On Node  : glaurung.internal.golden-gryphon.com
  7. # Last Modified By : Manoj Srivastava
  8. # Last Modified On : Fri Apr 14 19:30:45 2006
  9. # Last Machine Used: glaurung.internal.golden-gryphon.com
  10. # Update Count     : 81
  11. # Status           : Unknown, Use with caution!
  12. # HISTORY          : 
  13. # Description      : 
  14. # 
  15. # arch-tag: 1390e09f-ee31-4d7f-a968-bd539ea061a0
  16. #
  17. =head1 NAME
  18.  
  19. ucfq - query ucf registry and hashfile about configuration file details.
  20.  
  21. =cut
  22.  
  23. use strict;
  24.  
  25.  
  26. package ucf;
  27.  
  28. use strict;
  29. use Getopt::Long;
  30.  
  31. # set the version and revision
  32. ($main::MYNAME     = $main::0) =~ s|.*/||;
  33. $main::Author      = "Manoj Srivastava";
  34. $main::AuthorMail  = "srivasta\@debian.org";
  35.  
  36. =head1 SYNOPSIS
  37.  
  38.  usage: ucfq [options] (file|package)[file|package  ...]
  39.  
  40. =cut
  41.  
  42.  
  43. {  # scope for ultra-private meta-object for class attributes
  44.  
  45.   my %Ucf = 
  46.     (
  47.      Optdesc  => 
  48.      {
  49.       'help|h'         => sub {print ucf->Usage();     exit 0;},
  50.       'with-colons|w!' => sub {$::ConfOpts{"Colons"}= "$_[1]";},
  51.       'state-dir=s'    => sub {$::ConfOpts{"StateDir"}= "$_[1]";},
  52.       'debug|d'        => sub {$::ConfOpts{"DEBUG"}+= "$_[1]";},
  53.       'verbose|v'      => sub {$::ConfOpts{"VERBOSE"}+= "$_[1]";}
  54.      },
  55.      Usage => qq(Usage: $main::MYNAME [options]
  56. Author: $main::Author <$main::AuthorMail>
  57.   where options are:
  58.  --help                This message.
  59.  --debug               Turn on debugging mode.
  60.  --verbose             Make the script more verbose.
  61.  --with-colons         A compact, machine readable version of the output.
  62.  --state-dir </path/>  Set the state directory to /path/ instead of the
  63.                        default /var/lib/ucf.
  64.  
  65. ),
  66.      Defaults => 
  67.      {
  68.       "Colons"   => 0,
  69.       "DEBUG"    => 0,
  70.       "VERBOSE"  => 0,
  71.       "StateDir" => '/var/lib/ucf'
  72.      }
  73.     );
  74.   # tri-natured: function, class method, or object method
  75.   sub _classobj {
  76.     my $obclass = shift || __PACKAGE__;
  77.     my $class   = ref($obclass) || $obclass;
  78.     no strict "refs";   # to convert sym ref to real one
  79.     return \%$class;
  80.   }
  81.  
  82.   for my $datum (keys %Ucf ) {
  83.     no strict "refs";
  84.     *$datum = sub {
  85.       use strict "refs";
  86.       my ($self, $newvalue) = @_;
  87.       $Ucf{$datum} = $newvalue if @_ > 1;
  88.       return $Ucf{$datum};
  89.     }
  90.   }
  91. }
  92.  
  93. =head1 OPTIONS
  94.  
  95. =over 3
  96.  
  97. =item B<--help> B<h> Print out a usage message.
  98.  
  99. =item B<--debug> B<-d> Turn on debugging mode.
  100.  
  101. =item B<--verbose> B<-v> Make the script more verbose..
  102.  
  103. =item B<--with-colons> B<-w>
  104.  
  105. =over 2
  106.  
  107. Normally, the script presents the information in a human readable
  108. tabular format, but that may be harder for a machine to parse. With
  109. this option, the output is a compact, colon separated line, with no
  110. dividers, headers, or footer.
  111.  
  112. =back
  113.  
  114. =item B<--state-dr> dir
  115.  
  116. =over 2
  117.  
  118. Set the state directory to C</path/to/dir> instead of the default
  119. C</var/lib/ucf>.  Used mostly for testing.
  120.  
  121. =back
  122.  
  123. =back
  124.  
  125. =cut
  126.  
  127.  
  128. =head1 DESCRIPTION
  129.  
  130.  
  131. This script takes a set of arguments, each of which is a package or a
  132. path to a configuration file, and outputs the associated package, if
  133. any, if the file exists on disk, and whether it has been modfied by te
  134. user.  The output is either a human readable tabular form, or a
  135. compact colon-separated machine friendly format.
  136.  
  137. This script can potentially be used in package C<postinst> scripts
  138. during purge to query the system for configuration files that may
  139. still exist on the system, and whether these files have been locally
  140. modified by the user -- assuming that the package registered all the
  141. configuration files with B<ucf> using C<ucfr>.
  142.  
  143. =cut
  144.  
  145.  
  146.  
  147.  
  148. =head1 INTERNALS
  149.  
  150. =head2 Class Methods
  151.  
  152. All class methods mediate access to class variables.  All class
  153. methods can be invoked with zero or one parameters. When invoked with
  154. the optional parameter, the class method sets the value of the
  155. underlying class data.  In either case, the value of the underlying
  156. variable is returned.
  157.  
  158. =cut
  159.  
  160. =head1 Class ucf
  161.  
  162. This is a combination view and controller class that mediates between
  163. the user and the internal model classes.
  164.  
  165.  
  166. =head2 new
  167.  
  168. This is the constructor for the class. It takes a number of optional
  169. parameters. If the parameter B<Colons> is present, then the output
  170. will be compact. The parameters B<DEBUG> and B<VERBOSE> turn on
  171. additional diagnostics from the script.
  172.  
  173. =cut
  174.  
  175. sub new {
  176.   my $this = shift;
  177.   my %params = @_;
  178.   my $class = ref($this) || $this;
  179.   my $self = {};
  180.  
  181.   bless $self => $class;
  182.  
  183.   # validate and sanitize the settings
  184.   $self->validate(%params);
  185.   
  186.   return $self;
  187. }
  188.  
  189. =head2 validate
  190.  
  191. This routine is responsible for ensuring that the parameters passed in
  192. (presumably from the command line) are given preference. 
  193.  
  194. =cut
  195.  
  196. sub validate{
  197.   my $this     = shift;
  198.   my %params   = @_;
  199.   my $defaults = $this->Defaults();
  200.  
  201.  
  202.   # Make sure runtime options override what we get from the config file
  203.   for my $option (keys %params) {
  204.     $this->{Con_Ref}->{"$option"} = $params{"$option"};
  205.   }
  206.  
  207.   # Ensure that if default parameters have not been set on the comman
  208.   # line on in the configuration file, if any, we use the built in
  209.   # defaults.
  210.   for my $default (keys %$defaults) {
  211.     if (! defined $this->{Con_Ref}->{"$default"}) {
  212.       $this->{Con_Ref}->{"$default"} = $defaults->{"$default"};
  213.     }
  214.   }
  215. }
  216.  
  217. =head2 get_config_ref
  218.  
  219. This routine returns a reference to the configuration hash
  220.  
  221. =cut
  222.  
  223. sub get_config_ref {
  224.  
  225.   my $this     = shift;
  226.   return $this->{Con_Ref};
  227. }
  228.  
  229. =head2 dump_config 
  230.  
  231. This routine returns a C<Data::Dumper> for debugging purposes
  232.  
  233. =cut
  234.  
  235. sub dump_config {
  236.   my $this     = shift;
  237.   for (keys %{$this->{Con_Ref}}) {
  238.     print  "$_ = [${$this->{Con_Ref}}{$_}]\n"
  239.   }
  240. }
  241.  
  242. =head2 process
  243.  
  244. This routine is the work horse routine -- it parses the command line
  245. arguments, and queries the on disk databases, determines of the files
  246. exist, and have been modified.
  247.  
  248. =cut
  249.  
  250.  
  251. sub process {
  252.   my $this      = shift;
  253.  
  254. # Step 1: Process all arguments in sequence.
  255. # Step 2: determine if the arument given is a package name (no / in
  256. #         arg)
  257.  
  258.   %{$this->{packages}}    = map { +"$_" => 1} grep {! m,/,} @ARGV;
  259.   %{$this->{configs}}     = map { +"$_" => 1} grep {  m,/,} @ARGV;
  260.   $this->{pkg_list}       = object_list->new;
  261.   $this->{file_list}      = object_list->new;
  262.   $this->{registry_proxy} = 
  263.     registry->new("StateDir" => $this->{Con_Ref}->{StateDir});
  264.   $this->{hashfile_proxy} = 
  265.     hashfile->new("StateDir" => $this->{Con_Ref}->{StateDir});
  266.  
  267.   for (keys %{$this->{packages}} ) {
  268.     my $package = pkg->new('Name' => "$_");
  269.     $this->{pkg_list}->element($_, $package);
  270.   }
  271.   for (keys %{$this->{configs}}) {
  272.     warn "Need a fully qualified path name for config file \"$_\"\n"
  273.       unless m,^/,;
  274.     # Don't die for etch
  275.     exit 0 unless m,^/,;
  276.     my $file = conffile->new('Name' => "$_");
  277.     $this->{file_list}->element($_, $file);
  278.   }
  279. # Step 3: If so, gather all files associated with the package
  280.   for my $package ($this->{pkg_list}->list) {
  281.     my $pkg_files = $this->{registry_proxy}->list_files($package);
  282.     for my $file (@$pkg_files) {
  283.       if (! defined $this->{file_list}->element($file)) {
  284.         my $ret = conffile->new('Name' => "$file");
  285.         $this->{file_list}->element($file, $ret);
  286.       }
  287.       $this->{file_list}->element($file)->conffile_package($package);
  288.     }
  289.   }
  290. # Step 4: for all configuration files, determine package (unless
  291. #         already determined), if any
  292. # Step 5: For each configuration file, check if it exists
  293. # Step 6: For each existing file, see if it has been changed
  294.  
  295.   for my $file ($this->{file_list}->list) {
  296.     $this->{file_list}->element($file)->conffile_hash($file, $this->{hashfile_proxy}->hash($file));
  297.     if (! defined $this->{file_list}->element($file)->conffile_package) {
  298.       $this->{file_list}->element($file)->conffile_package($this->{registry_proxy}->find_pkg($file));
  299.     }
  300.   }
  301. }
  302.  
  303. =head2 report
  304.  
  305. This routine generates a nicely formatted report based on the
  306. information gathered during the processing. There are two kinds of
  307. reports, the first being a user friendly tabular form, the second
  308. (turned on by the C<-w> option) a easily parseable colon separated
  309. report.
  310.  
  311. =cut
  312.  
  313.  
  314. our ($out_pkg, $out_file, $there, $mod);
  315.  
  316. format STDOUT_TOP =
  317. Configuration file                            Package             Exists Changed
  318. .
  319.  
  320. format STDOUT =
  321. @<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<< @|||   @|||
  322. $out_file,                                    $out_pkg,           $there,$mod
  323. .
  324.  
  325. sub report {
  326.   my $this      = shift;
  327.   for my $file (sort $this->{file_list}->list) {
  328.     ($out_pkg, $out_file, $there, $mod) =
  329.       $this->{file_list}->element($file)->conffile_report;
  330.     if ($this->{Con_Ref}->{Colons}) {
  331.       print "$out_file:$out_pkg:$there:$mod\n";
  332.     }
  333.     else {
  334.       write;
  335.     }
  336.   }
  337. }
  338.  
  339. =head1 Class registry
  340.  
  341. This moel class encapsulates the package-configuration file
  342. associations registry.  It parses the data in the registry, and
  343. provides methods to query the registry based either on package name,
  344. or the full path of the configuration file.
  345.  
  346. =cut
  347.  
  348. package registry;
  349. use strict;
  350.  
  351. =head2 new
  352.  
  353. This is the constructor for the class.  It takes a required parameter
  354. B<StateDir>, and based on that, proceeds toparse the registry and
  355. populate internal data structures.
  356.  
  357. =cut
  358.  
  359. sub new {
  360.   my $this = shift;
  361.   my %params = @_;
  362.   my $class = ref($this) || $this;
  363.   my $self = {};
  364.  
  365.   die "Missing required parameter StateDir"
  366.     unless $params{StateDir};
  367.  
  368.   if (-e "$params{StateDir}/registry") {
  369.     if (! -r "$params{StateDir}/registry") {
  370.       die "Can't read registry file $params{StateDir}/registry:$!";
  371.     }
  372.     open (REG, "$params{StateDir}/registry") || 
  373.       die "Can't read registry file $params{StateDir}/registry:$!";
  374.     while (<REG>) {
  375.       chomp;
  376.       my ($pkg, $file) = m/^(\S+)\s+(\S+)$/;
  377.       $self->{Packages}->{$file} = $pkg;
  378.       if (exists $self->{List}->{$pkg}) {
  379.         push @{$self->{List}->{$pkg}}, $file;
  380.       }
  381.       else {
  382.         $self->{List}->{$pkg} = [ $file ];
  383.       }
  384.     }
  385.   }
  386.  
  387.   bless $self => $class;
  388.  
  389.   return $self;
  390. }
  391.  
  392. =head2 list_files
  393.  
  394. This routine queries the registry and lists all configuration files
  395. associated with the given package.  Takes the package name as a
  396. required parameter.
  397.  
  398. =cut
  399.  
  400. sub list_files {
  401.   my $this      = shift;
  402.   my $pkg       = shift;
  403.  
  404.   if (exists $this->{List}->{$pkg}) {
  405.     return [ @{$this->{List}->{$pkg}} ];
  406.   }
  407.   else {
  408.     return [];
  409.   }
  410. }
  411.  
  412.  
  413. =head2 find_pkg
  414.  
  415. This routine queries the registry for the package associated with the
  416. given file.  Takes the path of the configuration file as a required
  417. parameter.
  418.  
  419. =cut
  420.  
  421. sub find_pkg {
  422.   my $this      = shift;
  423.   my $file      = shift;
  424.  
  425.   if (exists $this->{Packages}->{$file}) {
  426.     return $this->{Packages}->{$file};
  427.   }
  428.   else {
  429.     return undef;
  430.   }
  431. }
  432.  
  433. =head1 Class hashfile
  434.  
  435. This moel class encapsulates the configuration file hash database.  It
  436. parses the data in the database, and provides methods to query the
  437. hash of the configuration file.
  438.  
  439. =cut
  440.  
  441. package hashfile;
  442. use strict;
  443.  
  444. sub new {
  445.   my $this = shift;
  446.   my %params = @_;
  447.   my $class = ref($this) || $this;
  448.   my $self = {};
  449.  
  450.   die "Missing required parameter StateDir"
  451.     unless $params{StateDir};
  452.  
  453.  
  454.   if (-e "$params{StateDir}/hashfile") {
  455.     if (! -r "$params{StateDir}/hashfile") {
  456.       die "Can't read registry file $params{StateDir}/hashfile:$!";
  457.     }
  458.     open (HASH, "$params{StateDir}/hashfile") || 
  459.       die "Can't read registry file $params{StateDir}/hashfile:$!";
  460.     while (<HASH>) {
  461.       chomp;
  462.       my ($hash, $file) = m/^(\S+)\s+(\S+)$/;
  463.       $self->{$file} = $hash
  464.     }
  465.   }
  466.  
  467.   bless $self => $class;
  468.  
  469.   return $self;
  470. }
  471.  
  472.  
  473. =head2 hash
  474.  
  475. This routine queries the database for the hash associated with the
  476. developers version of the given file.  Takes the path of the
  477. configuration file as a required parameter.
  478.  
  479. =cut
  480.  
  481.  
  482. sub hash {
  483.   my $this      = shift;
  484.   my $file      = shift;
  485.   my $value     = shift;
  486.  
  487.   if ($value) {
  488.     $this->{$file} = $value;
  489.   }
  490.   return $this->{$file};
  491. }
  492.  
  493. =head1 class conffile
  494.  
  495. This is the encapsulation of a configuration file metadata.
  496.  
  497. =cut
  498.  
  499.  
  500.  
  501. package conffile;
  502. use strict;
  503.  
  504.  
  505. =head2 new
  506.  
  507. This is the constructor for the class. It takes a number of optional
  508. parameters. If the parameter B<Colons> is present, then the output
  509. will be compact. The parameters B<DEBUG> and B<VERBOSE> turn on
  510. additional diagnostics from the script.
  511.  
  512. =cut
  513.  
  514. sub new {
  515.   my $this = shift;
  516.   my %params = @_;
  517.   my $class = ref($this) || $this;
  518.   my $self = {};
  519.  
  520.   die "Missing required parameter Name"
  521.     unless $params{Name};
  522.   $self->{Name}    = $params{Name};
  523.   $self->{Package} = $params{Package}
  524.     if $params{Package};
  525.   $self->{Exists}  = 'Yes' if -e $self->{Name};
  526.  
  527.   bless $self => $class;
  528.  
  529.   return $self;
  530. }
  531.  
  532.  
  533. =head2 conffile_package
  534.  
  535. This routine is the accessor method of the internal attribute that
  536. holds package name associated with the file.  If an optional C<value>
  537. is present, updates the value of the attribute.
  538.  
  539. =cut
  540.  
  541. sub conffile_package {
  542.   my $this      = shift;
  543.   my $value     = shift;
  544.  
  545.   if ($value ) {
  546.     $this->{Package} = $value;
  547.   }
  548.   if (exists $this->{Package}) {
  549.     return $this->{Package};
  550.   }
  551.   else {
  552.     return undef;
  553.   }
  554. }
  555.  
  556. =head2 conffile_exists
  557.  
  558. This routine is the accessor method of the internal attribute that
  559. holds the information whether the file exists on disk or not.
  560.  
  561. =cut
  562.  
  563. sub conffile_exists {
  564.   my $this      = shift;
  565.   my $name      = shift;
  566.   my $value     = shift;
  567.  
  568.   die "Missing required parameter Name"
  569.     unless $name;
  570.   if (exists $this->{Exists}) {
  571.     return $this->{Exists};
  572.   }
  573.   else {
  574.     return undef;
  575.   }
  576. }
  577.  
  578. =head2 conffile_modified
  579.  
  580. This routine is the accessor method of the internal attribute that
  581. holds the information whether the file exists on disk or not.  If an
  582. optional C<value> is present, updates the value of the attribute.
  583.  
  584. =cut
  585.  
  586. sub conffile_modified {
  587.   my $this      = shift;
  588.   my $name      = shift;
  589.   my $value     = shift;
  590.  
  591.   die "Missing required parameter Name"
  592.     unless $name;
  593.   if ($value ) {
  594.     $this->{Modified} = $value;
  595.   }
  596.   if (exists $this->{Modified}) {
  597.     return $this->{Modified};
  598.   }
  599.   else {
  600.     return undef;
  601.   }
  602. }
  603.  
  604. =head2 conffile_hash
  605.  
  606. This routine is the accessor method of the internal attribute that
  607. holds the hash for the developers version of the file.  If an optional
  608. C<value> is present, updates the value of the attribute.  It also
  609. notes whether or not the file is modified from the developers version.
  610.  
  611. =cut
  612.  
  613. sub conffile_hash {
  614.   my $this      = shift;
  615.   my $name      = shift;
  616.   my $value     = shift;
  617.  
  618.   die "Missing required parameter Name"
  619.     unless $name;
  620.   if ($value ) {
  621.     $this->{Hash} = $value;
  622.     if (-e "$name") {
  623.       if (-x "/usr/bin/md5sum") {
  624.         open (NEWHASH, "/usr/bin/md5sum $name |") || 
  625.           die "Could not run md5sum: $!";
  626.         while (<NEWHASH>) {
  627.           chomp;
  628.           my ($hash, $dummy) = m/^(\S+)\s+(\S+)$/;
  629.           if ("$hash" ne "$value") {
  630.             $this->{Modified} = 'Yes';
  631.           }
  632.           else {
  633.             $this->{Modified} = 'No';
  634.           }
  635.         }
  636.         close NEWHASH;
  637.       }
  638.       else {
  639.         die "Could not find /usr/bin/md5sum .\n";
  640.       }
  641.     }
  642.   }
  643.   if (exists $this->{Hash}) {
  644.     return $this->{Hash};
  645.   }
  646.   else {
  647.     return undef;
  648.   }
  649. }
  650.  
  651. sub conffile_report {
  652.   my $this      = shift;
  653.   return $this->{Package} ? $this->{Package} : "",
  654.     $this->{Name}, $this->{Exists} ? $this->{Exists} : "",
  655.       $this->{Modified}? $this->{Modified} : "";
  656. }
  657.  
  658.  
  659. =head1 CLASS PKG
  660.  
  661. This is an encapsulation of package metadata.  Packages may be
  662. associated with configuration files.
  663.  
  664. =cut
  665.  
  666.  
  667. package pkg;
  668. use strict;
  669.  
  670.  
  671. =head2 new
  672.  
  673. This is the constructor for the class. It takes a number of optional
  674. parameters. If the parameter B<Colons> is present, then the output
  675. will be compact. The parameters B<DEBUG> and B<VERBOSE> turn on
  676. additional diagnostics from the script.
  677.  
  678. =cut
  679.  
  680. sub new {
  681.   my $this = shift;
  682.   my %params = @_;
  683.   my $class = ref($this) || $this;
  684.   my $self = {};
  685.  
  686.   die "Missing required parameter Name"
  687.     unless $params{Name};
  688.   $self->{Name} = $params{Name};
  689.  
  690.   bless $self => $class;
  691.  
  692.   return $self;
  693. }
  694.  
  695. sub list_files {
  696.   my $this   = shift;
  697.   return [];
  698. }
  699.  
  700. =head1 CLASS object_list
  701.  
  702. This is a clas which holds lists of object names, either packages or
  703. configuration file object names.  It provides methods to add, access,
  704. and remove objects, as well as an option to list all elements in the
  705. list.
  706.  
  707. =cut
  708.  
  709. package object_list;
  710. use strict;
  711.  
  712.  
  713.  
  714. =head2 new
  715.  
  716. This is the constructor for the class. It takes no arguments.
  717.  
  718. =cut
  719.  
  720. sub new {
  721.   my $this = shift;
  722.   my %params = @_;
  723.   my $class = ref($this) || $this;
  724.   my $self = {};
  725.  
  726.   $self->{"List"} = ();
  727.  
  728.   bless $self => $class;
  729.  
  730.   return $self;
  731. }
  732.  
  733. =head2 element
  734.  
  735. This is an accessor method for elements of the list. If an optional
  736. value argument exists, it creates or updates the element associtated
  737. with the vaslue. Takes in a required name, which is used as a kay, and
  738. an optional value argument. The value is returned.
  739.  
  740. =cut
  741.  
  742. sub element {
  743.   my $this      = shift;
  744.   my $name      = shift;
  745.   my $value     = shift;
  746.   
  747.   die "Missing required parameter Name"
  748.     unless $name;
  749.   if ($value) {
  750.     $this->{"List"}->{$name} =  $value;
  751.   }
  752.   if (exists $this->{"List"}->{$name}) {
  753.     return $this->{"List"}->{$name};
  754.   }
  755.   else {
  756.     return undef;
  757.   }
  758. }
  759.  
  760.  
  761. =head2 remove
  762.  
  763. Removes elements from the list.  Take in an required name, which is
  764. used as the key for the element to delete.
  765.  
  766. =cut
  767.  
  768. sub remove {
  769.   my $this      = shift;
  770.   my $name      = shift;
  771.   die "Missing required parameter Name"
  772.     unless $name;
  773.   delete $this->{"List"}->{$name}
  774.     if (exists $this->{"List"}->{$name} );
  775. }
  776.  
  777. =head2 list
  778.  
  779. This routine lists all the elements in the list.  It does not take any
  780. options.
  781.  
  782. =cut
  783.  
  784. sub list {
  785.   my $this      = shift;
  786.  
  787.   return keys %{$this->{"List"}};
  788. }
  789.  
  790. package main;
  791. use Getopt::Long;
  792.  
  793. sub main {
  794.   my $optdesc = ucf->Optdesc();
  795.   my $parser  = new Getopt::Long::Parser;
  796.   $parser->configure("bundling");
  797.   $parser->getoptions (%$optdesc);
  798.   my $query = ucf->new(%::ConfOpts);
  799.   $query->process;
  800.   $query->report;
  801. }
  802.  
  803. &main;
  804.  
  805. exit 0;
  806.  
  807. =head1 CAVEATS
  808.  
  809. This is very inchoate, at the moment, and needs testing.
  810.  
  811. =cut
  812.  
  813. =head1 BUGS
  814.  
  815. None Known so far.
  816.  
  817. =cut
  818.  
  819. =head1 AUTHOR
  820.  
  821. Manoj Srivastava <srivasta\@debian.org>
  822.  
  823. =head1 COPYRIGHT AND LICENSE
  824.  
  825. This script is a part of the Ucf package, and is 
  826.  
  827. Copyright (c) 2006 Manoj Srivastava <srivasta\@debian.org>
  828.  
  829. This program is free software; you can redistribute it and / or modify
  830. it under the terms of the GNU General Public License as published by
  831. the Free Software Foundation; either version 2 of the License, or
  832. (at your option) any later version.
  833.  
  834. This program is distributed in the hope that it will be useful,
  835. but WITHOUT ANY WARRANTY; without even the implied warranty of
  836. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  837. GNU General Public License for more details.
  838.  
  839. You should have received a copy of the GNU General Public License
  840. along with this program; if not, write to the Free Software
  841. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  842.  
  843. =cut
  844.  
  845. 1;
  846.  
  847. __END__
  848.